{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "f6ac2d11-5aaa-4805-a72f-8dac049cb3f0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test set size: 10000\n",
      "Training set size: 60000\n",
      "Number of training samples: 43360\n",
      "Number of cross-validation samples: 10850\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "label_size = 18 # Label size\n",
    "ticklabel_size = 14 # Tick label size\n",
    "    \n",
    "# 定义一个转换以规范化数据\n",
    "transform = transforms.Compose([\n",
    "    transforms.ToTensor()\n",
    "])\n",
    "\n",
    "# 来自 MNIST 的负载测试数据\n",
    "TestData = torchvision.datasets.MNIST(root='D:/BaiduNetdiskDownload', train=False, download=False, transform=transform)\n",
    "print(f\"Test set size: {len(TestData)}\")\n",
    "\n",
    "# 来自 MNIST 的负载训练数据\n",
    "TrainData = torchvision.datasets.MNIST(root='D:/BaiduNetdiskDownload', train=True, download=False, transform=transform)\n",
    "print(f\"Training set size: {len(TrainData)}\")\n",
    "\n",
    "# Rate of trX and cvX\n",
    "rate = 0.8\n",
    "\n",
    "# Create a list to store indices for each class unique()\n",
    "CIndices = [[] for _ in range(10)]  # MNIST 中的 10 个类\n",
    "\n",
    "# 填充 CIndices\n",
    "for idx, (_, label) in enumerate(trainset):\n",
    "    CIndices[label].append(idx)\n",
    "\n",
    "# 计算训练集和验证集中每个类的样本数\n",
    "TrainNum_perclass = int(rate * min(len(indices) for indices in CIndices))\n",
    "ValNum_perclass = min(len(indices) for indices in CIndices) - TrainNum_perclass\n",
    "\n",
    "# 创建平衡的训练集和验证集\n",
    "TrIndices = []\n",
    "ValIndices = []\n",
    "for indices in CIndices:\n",
    "    TrIndices.extend(indices[:TrainNum_perclass])\n",
    "    ValIndices.extend(indices[TrainNum_perclass:TrainNum_perclass + ValNum_perclass])\n",
    "\n",
    "# 创建 Subset 数据集\n",
    "from torch.utils.data import Subset\n",
    "trX = Subset(TrainData, TrIndices)\n",
    "cvX = Subset(TrainData, ValIndices)\n",
    "\n",
    "print(f\"Number of training samples: {len(trX)}\")\n",
    "print(f\"Number of cross-validation samples: {len(cvX)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "4ea8f703-8541-4d81-9f80-f49b5afc9006",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "image_channels is 1\n",
      "tensor([[0., 0., 0., 1., 0., 0., 0., 0., 0., 0.],\n",
      "        [0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\n",
      "        [0., 0., 0., 1., 0., 0., 0., 0., 0., 0.],\n",
      "        [0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\n",
      "        [0., 0., 0., 0., 0., 0., 1., 0., 0., 0.],\n",
      "        [0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],\n",
      "        [0., 0., 0., 0., 0., 0., 0., 1., 0., 0.],\n",
      "        [0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],\n",
      "        [1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
      "        [0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],\n",
      "        [0., 0., 0., 0., 0., 0., 0., 1., 0., 0.],\n",
      "        [1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
      "        [0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],\n",
      "        [0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],\n",
      "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 1.],\n",
      "        [1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
      "        [0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],\n",
      "        [0., 0., 0., 1., 0., 0., 0., 0., 0., 0.],\n",
      "        [0., 0., 0., 0., 0., 0., 1., 0., 0., 0.],\n",
      "        [1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
      "        [0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],\n",
      "        [1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
      "        [0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],\n",
      "        [0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],\n",
      "        [0., 0., 0., 0., 0., 0., 1., 0., 0., 0.],\n",
      "        [0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],\n",
      "        [0., 0., 0., 0., 0., 0., 0., 1., 0., 0.],\n",
      "        [1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
      "        [1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
      "        [0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\n",
      "        [0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
      "        [0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],\n",
      "        [0., 0., 0., 0., 1., 0., 0., 0., 0., 0.],\n",
      "        [0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],\n",
      "        [1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
      "        [0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],\n",
      "        [0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
      "        [0., 0., 0., 0., 1., 0., 0., 0., 0., 0.],\n",
      "        [0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],\n",
      "        [0., 0., 0., 0., 0., 0., 1., 0., 0., 0.],\n",
      "        [0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\n",
      "        [0., 0., 1., 0., 0., 0., 0., 0., 0., 0.]])\n"
     ]
    }
   ],
   "source": [
    "batch_size = 42 # Define training batch 1，\n",
    "\n",
    "def one_hot_collate(batch):\n",
    "    data = torch.stack([item[0] for item in batch])\n",
    "    labels = torch.tensor([item[1] for item in batch])\n",
    "    one_hot_labels = torch.zeros(labels.size(0), 10)  # 10 classes in MNIST 【0，1，0，0】\n",
    "    one_hot_labels.scatter_(1, labels.unsqueeze(1), 1)\n",
    "    return data, one_hot_labels\n",
    "\n",
    "trLoader = torch.utils.data.DataLoader(trX, batch_size=batch_size, shuffle=True, num_workers=0, collate_fn=one_hot_collate)\n",
    "cvLoader = torch.utils.data.DataLoader(cvX, batch_size=batch_size, shuffle=False, num_workers=0, collate_fn=one_hot_collate)\n",
    "teLoader = torch.utils.data.DataLoader(TestData, batch_size=batch_size, shuffle=False, num_workers=0, collate_fn=one_hot_collate)\n",
    "\n",
    "# Get a batch of training data\n",
    "dataiter = iter(trLoader)\n",
    "data, labels = next(dataiter)\n",
    "\n",
    "image_channels = data[0].numpy().shape[0]\n",
    "print(f'image_channels is {image_channels}')\n",
    "print(labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "id": "e159a90f-0496-4c31-945d-13299975ec0a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CNN(\n",
      "  (conv1): Conv2d(1, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "  (pool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "  (conv2): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "  (pool2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "  (conv3): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "  (pool3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "  (fc1): Linear(in_features=1152, out_features=200, bias=True)\n",
      "  (fc2): Linear(in_features=200, out_features=100, bias=True)\n",
      "  (fc3): Linear(in_features=100, out_features=10, bias=True)\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "\n",
    "class CNN(nn.Module):\n",
    "    def __init__(self, image_channels, num_classes):\n",
    "        super(CNN, self).__init__()\n",
    "        \n",
    "        # 第一个卷积层\n",
    "        self.conv1 = nn.Conv2d(in_channels=image_channels, out_channels=32, kernel_size=3, padding=1)\n",
    "        self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2)\n",
    "        \n",
    "        # 第二个卷积层\n",
    "        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)\n",
    "        self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2)\n",
    "        \n",
    "        # 第三个卷积层\n",
    "        self.conv3 = nn.Conv2d(64, 128, kernel_size=3, padding=1)\n",
    "        self.pool3 = nn.MaxPool2d(kernel_size=2, stride=2)\n",
    "        \n",
    "        # 全连接层\n",
    "        # 假设输入图像大小为 28x28，在三个 2x2 最大池之后，28x28 -> 3x3\n",
    "        self.fc1 = nn.Linear(128 * 3 * 3, 200)  \n",
    "        self.fc2 = nn.Linear(200, 100)  \n",
    "        self.fc3 = nn.Linear(100, num_classes)  \n",
    "        \n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.conv1(x))\n",
    "        x = self.pool1(x)\n",
    "        \n",
    "        x = F.relu(self.conv2(x))\n",
    "        x = self.pool2(x)\n",
    "        \n",
    "        x = F.relu(self.conv3(x))\n",
    "        x = self.pool3(x)\n",
    "        \n",
    "        # 展平全连接层的输出\n",
    "        x = x.view(-1, 128 * 3 * 3)\n",
    "        \n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = self.fc3(x)\n",
    "        \n",
    "        return x\n",
    "\n",
    "# 初始化模型\n",
    "image_channels = 1 # 对于灰度图像，使用 1;对于 RGB 图像，请使用 3\n",
    "num_classes = 10\n",
    "CNNmodel = CNN(image_channels, num_classes)\n",
    "\n",
    "if torch.cuda.is_available():\n",
    "    CNNmodel = CNNmodel.cuda()\n",
    "\n",
    "# 显示模型架构\n",
    "print(CNNmodel)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "id": "3a3e21f0-31e2-43a3-be00-dd562f820e18",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [1/35], Train Loss: 0.0477, CV Loss: 0.0614\n",
      "Epoch [2/35], Train Loss: 0.0343, CV Loss: 0.0434\n",
      "Epoch [3/35], Train Loss: 0.0266, CV Loss: 0.0396\n",
      "Epoch [4/35], Train Loss: 0.0205, CV Loss: 0.0427\n",
      "Epoch [5/35], Train Loss: 0.0172, CV Loss: 0.0442\n",
      "Epoch [6/35], Train Loss: 0.0159, CV Loss: 0.0612\n",
      "Epoch [7/35], Train Loss: 0.0147, CV Loss: 0.0569\n",
      "Epoch [8/35], Train Loss: 0.0109, CV Loss: 0.0535\n",
      "Epoch [9/35], Train Loss: 0.0117, CV Loss: 0.0499\n",
      "Epoch [10/35], Train Loss: 0.0093, CV Loss: 0.0497\n",
      "Epoch [11/35], Train Loss: 0.0093, CV Loss: 0.0625\n",
      "Epoch [12/35], Train Loss: 0.0090, CV Loss: 0.0540\n",
      "Epoch [13/35], Train Loss: 0.0065, CV Loss: 0.0623\n",
      "Epoch [14/35], Train Loss: 0.0088, CV Loss: 0.0496\n",
      "Epoch [15/35], Train Loss: 0.0069, CV Loss: 0.0696\n",
      "Epoch [16/35], Train Loss: 0.0076, CV Loss: 0.0547\n",
      "Epoch [17/35], Train Loss: 0.0051, CV Loss: 0.0606\n",
      "Epoch [18/35], Train Loss: 0.0075, CV Loss: 0.0768\n",
      "Epoch [19/35], Train Loss: 0.0066, CV Loss: 0.0533\n",
      "Epoch [20/35], Train Loss: 0.0044, CV Loss: 0.0662\n",
      "Epoch [21/35], Train Loss: 0.0067, CV Loss: 0.0642\n",
      "Epoch [22/35], Train Loss: 0.0062, CV Loss: 0.0484\n",
      "Epoch [23/35], Train Loss: 0.0046, CV Loss: 0.0590\n",
      "Epoch [24/35], Train Loss: 0.0066, CV Loss: 0.0572\n",
      "Epoch [25/35], Train Loss: 0.0029, CV Loss: 0.0640\n",
      "Epoch [26/35], Train Loss: 0.0047, CV Loss: 0.0773\n",
      "Epoch [27/35], Train Loss: 0.0072, CV Loss: 0.0670\n",
      "Epoch [28/35], Train Loss: 0.0042, CV Loss: 0.0717\n",
      "Epoch [29/35], Train Loss: 0.0045, CV Loss: 0.0812\n",
      "Epoch [30/35], Train Loss: 0.0046, CV Loss: 0.0765\n",
      "Epoch [31/35], Train Loss: 0.0041, CV Loss: 0.0755\n",
      "Epoch [32/35], Train Loss: 0.0046, CV Loss: 0.0784\n",
      "Epoch [33/35], Train Loss: 0.0047, CV Loss: 0.0700\n",
      "Epoch [34/35], Train Loss: 0.0050, CV Loss: 0.0814\n",
      "Epoch [35/35], Train Loss: 0.0034, CV Loss: 0.0930\n"
     ]
    }
   ],
   "source": [
    "# 定义损失函数和优化器\n",
    "criterion = nn.CrossEntropyLoss()  # 损失函数\n",
    "optimizer = optim.Adam(CNNmodel.parameters())  # Adam优化器\n",
    "\n",
    "# 存储损失的列表\n",
    "TrainLosses = []\n",
    "CVLosses = []\n",
    "\n",
    "# 训练的轮数\n",
    "num_epochs = 35\n",
    "\n",
    "# 检查是否有可用的GPU\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "CNNmodel.to(device)  # 将模型移动到GPU（如果可用）\n",
    "\n",
    "for epoch in range(num_epochs):\n",
    "    CNNmodel.train()  # 设置模型为训练模式\n",
    "    BatchLosses = []\n",
    "    \n",
    "    for batchx, batchy in trLoader:\n",
    "        batchx, batchy = batchx.to(device), batchy.to(device)  # 将数据移动到GPU（如果可用）\n",
    "        \n",
    "        # 前向传播\n",
    "        batchoutputs = CNNmodel(batchx)\n",
    "        batchloss = criterion(batchoutputs, batchy)\n",
    "        \n",
    "        # 反向传播和优化\n",
    "        optimizer.zero_grad()\n",
    "        batchloss.backward()\n",
    "        optimizer.step()\n",
    "        \n",
    "        BatchLosses.append(batchloss.item())\n",
    "    \n",
    "    # 计算这个epoch的平均训练损失\n",
    "    avgtrloss = sum(BatchLosses) / len(BatchLosses)\n",
    "    TrainLosses.append(avgtrloss)\n",
    "    \n",
    "    # 在交叉验证集上评估\n",
    "    CNNmodel.eval()  # 设置模型为评估模式\n",
    "    cvBatchLosses = []\n",
    "    with torch.no_grad():  # 在评估模式下，不计算梯度\n",
    "        for cvx, cvy in cvLoader:\n",
    "            cvx, cvy = cvx.to(device), cvy.to(device)  # 将数据移动到GPU（如果可用）\n",
    "            \n",
    "            cvoutputs = CNNmodel(cvx)\n",
    "            cvloss = criterion(cvoutputs, cvy)\n",
    "            cvBatchLosses.append(cvloss.item())\n",
    "    \n",
    "    avgcvloss = sum(cvBatchLosses) / len(cvBatchLosses)\n",
    "    CVLosses.append(avgcvloss)\n",
    "    \n",
    "    print(f'Epoch [{epoch+1}/{num_epochs}], Train Loss: {avgtrloss:.4f}, CV Loss: {avgcvloss:.4f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "id": "93712cdd-a045-43fe-bb47-2f780dffadb0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on training set: 99.81%\n",
      "Accuracy on cross-validation set: 98.77%\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 计算和打印训练集和交叉验证集的准确率\n",
    "# 确定设备\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "# 将模型移动到设备上\n",
    "CNNmodel = CNNmodel.to(device)\n",
    "\n",
    "CNNmodel.eval()\n",
    "with torch.no_grad():\n",
    "    # 训练集准确率\n",
    "    TrainCorrect = 0\n",
    "    TrainTotal = 0\n",
    "    for images, labels in trLoader:\n",
    "        # 将数据移动到设备上\n",
    "        images, labels = images.to(device), labels.to(device)\n",
    "        \n",
    "        outputs = CNNmodel(images)\n",
    "        _, predicted = torch.max(outputs, 1)\n",
    "        _, true_labels = torch.max(labels, 1)\n",
    "        TrainTotal += labels.size(0)\n",
    "        TrainCorrect += (predicted == true_labels).sum().item()\n",
    "    \n",
    "    TrainAccuracy = 100 * TrainCorrect / TrainTotal\n",
    "    \n",
    "   # 测试集精度\n",
    "    CVcorrect = 0\n",
    "    CVtotal = 0\n",
    "    for images, labels in cvLoader:\n",
    "        # 将数据移动到设备上\n",
    "        images, labels = images.to(device), labels.to(device)\n",
    "        \n",
    "        outputs = CNNmodel(images)\n",
    "        _, predicted = torch.max(outputs, 1)\n",
    "        _, true_labels = torch.max(labels, 1)\n",
    "        CVtotal += labels.size(0)\n",
    "        CVcorrect += (predicted == true_labels).sum().item()\n",
    "    \n",
    "    CVAccuracy = 100 * CVcorrect / CVtotal\n",
    "\n",
    "print(f'Accuracy on training set: {TrainAccuracy:.2f}%')\n",
    "print(f'Accuracy on cross-validation set: {CVAccuracy:.2f}%')\n",
    "\n",
    "# 绘制训练和交叉验证损失\n",
    "plt.figure(figsize=(10, 5))\n",
    "plt.plot(range(1, num_epochs+1), TrainLosses, label='Training Loss')\n",
    "plt.plot(range(1, num_epochs+1), CVLosses, label='Cross-Validation Loss')\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Loss')\n",
    "plt.title('Training and Cross-Validation Loss')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
